Usenet 1993 July

home *** CD-ROM | disk | FTP | other *** search

/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume14 / flex / part02 < prev next >

Wrap

Internet Message Format | 1988-05-02 | 55.9 KB

Subject: v14i080: Flex, a lex replacement, Part02/05 Newsgroups: comp.sources.unix Sender: sources Approved: rsalz@uunet.UU.NET Submitted-by: Vern Paxson <vern@lbl-csam.arpa> Posting-number: Volume 14, Issue 80 Archive-name: flex/part02 #! /bin/sh # This is a shell archive. Remove anything before this line, then unpack # it by saving it into a file and typing "sh file". To overwrite existing # files, type "sh file -c". You can also feed this as standard input via # unshar, or by typing "sh <file", e.g.. If this archive is complete, you # will see the following message at the end: # "End of archive 2 (of 5)." # Contents: dfa.c flex.fastskel main.c misc.c scan.l # Wrapped by rsalz@fig.bbn.com on Tue May 3 17:31:27 1988 PATH=/bin:/usr/bin:/usr/ucb ; export PATH if test -f 'dfa.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'dfa.c'\" else echo shar: Extracting \"'dfa.c'\" $10732 characters$ sed "s/^X//" >'dfa.c' <<'END_OF_FILE' X/* dfa - DFA construction routines */ X X/* X * Copyright (c) 1987, the University of California X * X * The United States Government has rights in this work pursuant to X * contract no. DE-AC03-76SF00098 between the United States Department of X * Energy and the University of California. X * X * This program may be redistributed. Enhancements and derivative works X * may be created provided the new works, if made available to the general X * public, are made available for use by anyone. X */ X X#include "flexdef.h" X X/* epsclosure - construct the epsilon closure of a set of ndfa states X * X * synopsis X * int t[current_max_dfa_size], numstates, accset[accnum + 1], nacc; X * int hashval; X * int *epsclosure(); X * t = epsclosure( t, &numstates, accset, &nacc, &hashval ); X * X * NOTES X * the epsilon closure is the set of all states reachable by an arbitrary X * number of epsilon transitions which themselves do not have epsilon X * transitions going out, unioned with the set of states which have non-null X * accepting numbers. t is an array of size numstates of nfa state numbers. X * Upon return, t holds the epsilon closure and numstates is updated. accset X * holds a list of the accepting numbers, and the size of accset is given X * by nacc. t may be subjected to reallocation if it is not large enough X * to hold the epsilon closure. X * X * hashval is the hash value for the dfa corresponding to the state set X */ X int *epsclosure( t, ns_addr, accset, nacc_addr, hv_addr ) int *t, *ns_addr, accset[], *nacc_addr, *hv_addr; X X { X register int stkpos, ns, tsp; X int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum; X int stkend, nstate; X static int did_stk_init = false, *stk; X X#define MARK_STATE(state) \ X trans1[state] = trans1[state] - MARKER_DIFFERENCE; X X#define IS_MARKED(state) (trans1[state] < 0) X X#define UNMARK_STATE(state) \ X trans1[state] = trans1[state] + MARKER_DIFFERENCE; X X#define CHECK_ACCEPT(state) \ X { \ X nfaccnum = accptnum[state]; \ X if ( nfaccnum != NIL ) \ X accset[++nacc] = nfaccnum; \ X } X X#define DO_REALLOCATION \ X { \ X current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \ X ++num_reallocs; \ X t = reallocate_integer_array( t, current_max_dfa_size ); \ X stk = reallocate_integer_array( stk, current_max_dfa_size ); \ X } \ X X#define PUT_ON_STACK(state) \ X { \ X if ( ++stkend >= current_max_dfa_size ) \ X DO_REALLOCATION \ X stk[stkend] = state; \ X MARK_STATE(state) \ X } X X#define ADD_STATE(state) \ X { \ X if ( ++numstates >= current_max_dfa_size ) \ X DO_REALLOCATION \ X t[numstates] = state; \ X hashval = hashval + state; \ X } X X#define STACK_STATE(state) \ X { \ X PUT_ON_STACK(state) \ X CHECK_ACCEPT(state) \ X if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \ X ADD_STATE(state) \ X } X X if ( ! did_stk_init ) X { X stk = allocate_integer_array( current_max_dfa_size ); X did_stk_init = true; X } X X nacc = stkend = hashval = 0; X X for ( nstate = 1; nstate <= numstates; ++nstate ) X { X ns = t[nstate]; X X /* the state could be marked if we've already pushed it onto X * the stack X */ X if ( ! IS_MARKED(ns) ) X PUT_ON_STACK(ns) X X CHECK_ACCEPT(ns) X hashval = hashval + ns; X } X X for ( stkpos = 1; stkpos <= stkend; ++stkpos ) X { X ns = stk[stkpos]; X transsym = transchar[ns]; X X if ( transsym == SYM_EPSILON ) X { X tsp = trans1[ns] + MARKER_DIFFERENCE; X X if ( tsp != NO_TRANSITION ) X { X if ( ! IS_MARKED(tsp) ) X STACK_STATE(tsp) X X tsp = trans2[ns]; X X if ( tsp != NO_TRANSITION ) X if ( ! IS_MARKED(tsp) ) X STACK_STATE(tsp) X } X } X } X X /* clear out "visit" markers */ X X for ( stkpos = 1; stkpos <= stkend; ++stkpos ) X { X if ( IS_MARKED(stk[stkpos]) ) X { X UNMARK_STATE(stk[stkpos]) X } X else X flexfatal( "consistency check failed in epsclosure()" ); X } X X *ns_addr = numstates; X *hv_addr = hashval; X *nacc_addr = nacc; X X return ( t ); X } X X X X/* increase_max_dfas - increase the maximum number of DFAs */ X increase_max_dfas() X X { X int old_max = current_max_dfas; X X current_max_dfas += MAX_DFAS_INCREMENT; X X ++num_reallocs; X X base = reallocate_integer_array( base, current_max_dfas ); X def = reallocate_integer_array( def, current_max_dfas ); X dfasiz = reallocate_integer_array( dfasiz, current_max_dfas ); X accsiz = reallocate_integer_array( accsiz, current_max_dfas ); X dhash = reallocate_integer_array( dhash, current_max_dfas ); X todo = reallocate_integer_array( todo, current_max_dfas ); X dss = reallocate_integer_pointer_array( dss, current_max_dfas ); X dfaacc = reallocate_dfaacc_union( dfaacc, current_max_dfas ); X X /* fix up todo queue */ X if ( todo_next < todo_head ) X { /* queue was wrapped around the end */ X register int i; X X for ( i = 0; i < todo_next; ++i ) X todo[old_max + i] = todo[i]; X X todo_next += old_max; X } X } X X X/* snstods - converts a set of ndfa states into a dfa state X * X * synopsis X * int sns[numstates], numstates, newds, accset[accnum + 1], nacc, hashval; X * int snstods(); X * is_new_state = snstods( sns, numstates, accset, nacc, hashval, &newds ); X * X * on return, the dfa state number is in newds. X */ X int snstods( sns, numstates, accset, nacc, hashval, newds_addr ) int sns[], numstates, accset[], nacc, hashval, *newds_addr; X X { X int didsort = 0; X register int i, j; X int newds, *oldsns; X char *malloc(); X X for ( i = 1; i <= lastdfa; ++i ) X if ( hashval == dhash[i] ) X { X if ( numstates == dfasiz[i] ) X { X oldsns = dss[i]; X X if ( ! didsort ) X { X /* we sort the states in sns so we can compare it to X * oldsns quickly. we use bubble because there probably X * aren't very many states X */ X bubble( sns, numstates ); X didsort = 1; X } X X for ( j = 1; j <= numstates; ++j ) X if ( sns[j] != oldsns[j] ) X break; X X if ( j > numstates ) X { X ++dfaeql; X *newds_addr = i; X return ( 0 ); X } X X ++hshcol; X } X X else X ++hshsave; X } X X /* make a new dfa */ X X if ( ++lastdfa >= current_max_dfas ) X increase_max_dfas(); X X newds = lastdfa; X X if ( ! (dss[newds] = (int *) malloc( (unsigned) ((numstates + 1) * sizeof( int )) )) ) X flexfatal( "dynamic memory failure in snstods()" ); X X /* if we haven't already sorted the states in sns, we do so now, so that X * future comparisons with it can be made quickly X */ X X if ( ! didsort ) X bubble( sns, numstates ); X X for ( i = 1; i <= numstates; ++i ) X dss[newds][i] = sns[i]; X X dfasiz[newds] = numstates; X dhash[newds] = hashval; X X if ( nacc == 0 ) X { X dfaacc[newds].dfaacc_state = 0; X accsiz[newds] = 0; X } X X else if ( reject ) X { X /* we sort the accepting set in increasing order so the disambiguating X * rule that the first rule listed is considered match in the event of X * ties will work. We use a bubble sort since the list is probably X * quite small. X */ X X bubble( accset, nacc ); X X dfaacc[newds].dfaacc_state = X (int) malloc( (unsigned) ((nacc + 1) * sizeof( int )) ); X X if ( ! dfaacc[newds].dfaacc_state ) X flexfatal( "dynamic memory failure in snstods()" ); X X /* save the accepting set for later */ X for ( i = 1; i <= nacc; ++i ) X dfaacc[newds].dfaacc_set[i] = accset[i]; X X accsiz[newds] = nacc; X } X X else X { /* find lowest numbered rule so the disambiguating rule will work */ X j = accnum + 1; X X for ( i = 1; i <= nacc; ++i ) X if ( accset[i] < j ) X j = accset[i]; X X dfaacc[newds].dfaacc_state = j; X } X X *newds_addr = newds; X X return ( 1 ); X } X X X/* symfollowset - follow the symbol transitions one step X * X * synopsis X * int ds[current_max_dfa_size], dsize, transsym; X * int nset[current_max_dfa_size], numstates; X * numstates = symfollowset( ds, dsize, transsym, nset ); X */ X int symfollowset( ds, dsize, transsym, nset ) int ds[], dsize, transsym, nset[]; X X { X int ns, tsp, sym, i, j, lenccl, ch, numstates; X int ccllist; X X numstates = 0; X X for ( i = 1; i <= dsize; ++i ) X { /* for each nfa state ns in the state set of ds */ X ns = ds[i]; X sym = transchar[ns]; X tsp = trans1[ns]; X X if ( sym < 0 ) X { /* it's a character class */ X sym = -sym; X ccllist = cclmap[sym]; X lenccl = ccllen[sym]; X X if ( cclng[sym] ) X { X for ( j = 0; j < lenccl; ++j ) X { /* loop through negated character class */ X ch = ccltbl[ccllist + j]; X X if ( ch > transsym ) X break; /* transsym isn't in negated ccl */ X X else if ( ch == transsym ) X /* next 2 */ goto bottom; X } X X /* didn't find transsym in ccl */ X nset[++numstates] = tsp; X } X X else X for ( j = 0; j < lenccl; ++j ) X { X ch = ccltbl[ccllist + j]; X X if ( ch > transsym ) X break; X X else if ( ch == transsym ) X { X nset[++numstates] = tsp; X break; X } X } X } X X else if ( sym >= 'A' && sym <= 'Z' && caseins ) X flexfatal( "consistency check failed in symfollowset" ); X X else if ( sym == SYM_EPSILON ) X { /* do nothing */ X } X X else if ( ecgroup[sym] == transsym ) X nset[++numstates] = tsp; X bottom: X ; X } X X return ( numstates ); X } X X X/* sympartition - partition characters with same out-transitions X * X * synopsis X * integer ds[current_max_dfa_size], numstates, duplist[numecs]; X * symlist[numecs]; X * sympartition( ds, numstates, symlist, duplist ); X */ X sympartition( ds, numstates, symlist, duplist ) int ds[], numstates, duplist[]; int symlist[]; X X { X int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich; X X /* partitioning is done by creating equivalence classes for those X * characters which have out-transitions from the given state. Thus X * we are really creating equivalence classes of equivalence classes. X */ X X for ( i = 1; i <= numecs; ++i ) X { /* initialize equivalence class list */ X duplist[i] = i - 1; X dupfwd[i] = i + 1; X } X X duplist[1] = NIL; X dupfwd[numecs] = NIL; X X for ( i = 1; i <= numstates; ++i ) X { X ns = ds[i]; X tch = transchar[ns]; X X if ( tch != SYM_EPSILON ) X { X if ( tch < -lastccl || tch > CSIZE ) X flexfatal( "bad transition character detected in sympartition()" ); X X if ( tch > 0 ) X { /* character transition */ X mkechar( ecgroup[tch], dupfwd, duplist ); X symlist[ecgroup[tch]] = 1; X } X X else X { /* character class */ X tch = -tch; X X lenccl = ccllen[tch]; X cclp = cclmap[tch]; X mkeccl( ccltbl + cclp, lenccl, dupfwd, duplist, numecs ); X X if ( cclng[tch] ) X { X j = 0; X X for ( k = 0; k < lenccl; ++k ) X { X ich = ccltbl[cclp + k]; X X for ( ++j; j < ich; ++j ) X symlist[j] = 1; X } X X for ( ++j; j <= numecs; ++j ) X symlist[j] = 1; X } X X else X for ( k = 0; k < lenccl; ++k ) X { X ich = ccltbl[cclp + k]; X symlist[ich] = 1; X } X } X } X } X } END_OF_FILE if test 10732 -ne `wc -c <'dfa.c'`; then echo shar: \"'dfa.c'\" unpacked with wrong size! fi # end of 'dfa.c' fi if test -f 'flex.fastskel' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'flex.fastskel'\" else echo shar: Extracting \"'flex.fastskel'\" $9304 characters$ sed "s/^X//" >'flex.fastskel' <<'END_OF_FILE' X/* A lexical scanner generated by flex */ X X#define FLEX_FAST_SKEL X X#include "fastskeldef.h" X X%% section 1 code and the definition of YY_TRANS_OFFSET_TYPE, if needed, go here X X#ifndef FLEX_FULL_TABLE X /* struct for yy_transition */ X struct yy_trans_info X { X /* v is a verify for a transition. */ X short v; X X /* In cases where its sister v *is* a "yes, there is a transition", X * n is* the offset (in records) to the next state. In most cases X * where there is no transition, the value of n is irrelevant. If n X * is the -1th record of a state, though, then n is the action X * number for that state X */ X YY_TRANS_OFFSET_TYPE n; X }; X#endif X X%% data tables for DFA go here X X/* these declarations have to come after the section 1 code or lint gets X * confused about whether the variables are used X */ XFILE *yyin = stdin, *yyout = stdout; X X/* these variables are all declared out here so that section 3 code can X * manipulate them X */ static char *yy_c_buf_p; /* points to current character in buffer */ static char *yy_b_buf_p; /* points to start of current scan */ static int yy_init = 1; /* whether we need to initialize */ static int yy_start; /* start state number */ X X/* true when we've seen an EOF for the current input file */ static int yy_eof_has_been_seen; X static int yy_n_chars; /* number of characters read into yy_ch_buf */ X X/* yy_ch_buf has to be 2 characters longer than YY_BUF_SIZE because we need X * to put in 2 end-of-buffer characters (this is explained where it is X * done) at the end of yy_ch_buf X */ static char yy_ch_buf[YY_BUF_SIZE + 2]; X X/* yy_hold_char holds the character lost when yytext is formed */ static char yy_hold_char; char *yytext; static int yyleng; /* length of yytext */ X static YY_CS_TYPE yy_last_accepting_state; static char *yy_last_accepting_cpos; X static YY_CS_TYPE yy_get_previous_state(); static int yy_get_next_buffer(); X X#define FLEX_USES_BACKTRACKING X X#ifdef FLEX_USES_BACKTRACKING X# ifdef FLEX_FULL_TABLE X# define YY_BACKTRACKING_ACTION \ X if ( l[yy_current_state] ) \ X { \ X yy_last_accepting_state = yy_current_state; \ X yy_last_accepting_cpos = yy_c_buf_p; \ X } X# else X# define YY_BACKTRACKING_ACTION \ X if ( yy_current_state[-1].n ) \ X { \ X yy_last_accepting_state = yy_current_state; \ X yy_last_accepting_cpos = yy_c_buf_p; \ X } X# endif X#else X# define YY_BACKTRACKING_ACTION X#endif X YY_DECL X { X register YY_CS_TYPE yy_current_state; X register int yy_c; X register struct yy_trans_info *yy_trans_info; X register int yy_act; X X%% user's declarations go here X X if ( yy_init ) X { X yy_start = 1; /* first start state */ X new_file: X /* this is where we enter upon encountering and end-of-file and X * yywrap() indicating that we should continue processing X */ X X /* we put in the '\n' and start reading from [1] so that an X * initial match-at-newline will be true. X */ X X yy_ch_buf[0] = '\n'; X yy_n_chars = 1; X X /* we always need two end-of-buffer characters. The first causes X * a transition to the end-of-buffer state. The second causes X * a jam in that state. X */ X yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; X yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; X X yy_eof_has_been_seen = 0; X X YY_FAST_INIT; X yy_init = 0; X } X X while ( 1 ) /* loops until end-of-file is reached */ X { X /* support of yytext and yyleng */ X YY_DO_BEFORE_SCAN; X X /* yy_b_buf_p points to the position in yy_ch_buf of the start of the X * current run. X */ X yy_b_buf_p = yy_c_buf_p; X X YY_FIND_START_STATE( yy_current_state ); X X YY_FIND_NEXT_MATCH; X X YY_DO_BEFORE_ACTION; X X/* we need this label to process the very last action (right before the end of X * the file) X */ do_action: X YY_FIND_ACTION( yy_act ); X X#ifdef FLEX_DEBUG X fprintf( stderr, "--accepting rule #%d\n", yy_act ); X#endif X switch ( yy_act ) X { X%% actions go here X X case YY_BACK_TRACK: X YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */ X yy_c_buf_p = yy_last_accepting_cpos + 1; X yy_current_state = yy_last_accepting_state; X YY_DO_BEFORE_ACTION; X goto do_action; X X case YY_NEW_FILE: X break; /* begin reading from new file */ X X case YY_DO_DEFAULT: X /* we have to eat up one character and recompute yytext and X * yyleng X */ X YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */ X ++yy_c_buf_p; X YY_DO_BEFORE_ACTION; X YY_DEFAULT_ACTION; X break; X X case YY_END_OF_BUFFER: X YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */ X X switch ( yy_get_next_buffer() ) X { X case EOB_ACT_END_OF_FILE: X { X if ( yywrap() ) X { X /* note: because we've taken care in X * yy_get_next_buffer() to have set up yy_b_buf_p, X * we can now set up yy_c_buf_p so that if some X * total hoser (like flex itself) wants X * to call the scanner after we return the X * YY_NULL, it'll still work - another YY_NULL X * will get returned. X */ X yy_c_buf_p = yy_b_buf_p; X return ( YY_NULL ); X } X X else X goto new_file; X } X break; X X case EOB_ACT_RESTART_SCAN: X yy_c_buf_p = yy_b_buf_p; X X YY_DO_BEFORE_RESTART; X break; X X case EOB_ACT_LAST_MATCH: X yy_c_buf_p = &yy_ch_buf[yy_n_chars]; X X yy_current_state = yy_get_previous_state(); X X YY_DO_BEFORE_ACTION; X X goto do_action; X } X break; X X default: X printf( "action # %d\n", yy_act ); X YY_FATAL_ERROR( "fatal flex scanner internal error" ); X } X } X } X X X/* yy_get_next_buffer - try to read in new buffer X * X * synopsis X * int yy_get_next_buffer(); X * X * returns a code representing an action X * EOB_ACT_LAST_MATCH - X * EOB_ACT_RESTART_SCAN - restart the scanner X * EOB_ACT_END_OF_FILE - end of file X */ X static int yy_get_next_buffer() X X { X if ( yy_c_buf_p != &yy_ch_buf[yy_n_chars + 1] ) X { X YY_FATAL_ERROR( "NULL in input" ); X /*NOTREACHED*/ X } X X else X { /* try to read more data */ X register char *dest = yy_ch_buf; X register char *source = yy_b_buf_p - 1; /* copy prev. char, too */ X register int number_to_move, i; X int ret_val; X X /* first move last chars to start of buffer */ X number_to_move = yy_c_buf_p - yy_b_buf_p; X X for ( i = 0; i < number_to_move; ++i ) X *(dest++) = *(source++); X X if ( yy_eof_has_been_seen ) X /* don't do the read, it's not guaranteed to return an EOF, X * just force an EOF X */ X yy_n_chars = 0; X X else X /* read in more data */ X YY_INPUT( (&yy_ch_buf[number_to_move]), yy_n_chars, X YY_BUF_SIZE - number_to_move - 1 ); X X if ( yy_n_chars == 0 ) X { X if ( number_to_move == 1 ) X ret_val = EOB_ACT_END_OF_FILE; X else X ret_val = EOB_ACT_LAST_MATCH; X X yy_eof_has_been_seen = 1; X } X X else X ret_val = EOB_ACT_RESTART_SCAN; X X yy_n_chars += number_to_move; X yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; X yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; X X /* yy_b_buf_p begins at the second character in X * yy_ch_buf; the first character is the one which X * preceded it before reading in the latest buffer; X * it needs to be kept around in case it's a X * newline, so yy_get_previous_state() will have X * with '^' rules active X */ X X yy_b_buf_p = &yy_ch_buf[1]; X X return ( ret_val ); X } X } X X X/* yy_get_previous_state - get the state just before the eob char was reached X * X * synopsis X * YY_CS_TYPE yy_get_previous_state(); X */ X static YY_CS_TYPE yy_get_previous_state() X X { X register YY_CS_TYPE yy_cur_state; X register char *yy_temp_char_ptr; X X YY_FIND_START_STATE( yy_cur_state ); X X for ( yy_temp_char_ptr = yy_b_buf_p; yy_temp_char_ptr < yy_c_buf_p; ) X YY_GET_NEXT_STATE; X X return ( yy_cur_state ); X } X X static unput( c ) int c; X X { X YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */ X X if ( yy_c_buf_p < yy_ch_buf + 2 ) X { /* need to shift things up to make room */ X register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */ X register char *dest = &yy_ch_buf[YY_BUF_SIZE + 2]; X register char *source = &yy_ch_buf[number_to_move]; X X while ( source > yy_ch_buf ) X *--dest = *--source; X X yy_c_buf_p += dest - source; X yy_b_buf_p += dest - source; X X if ( yy_c_buf_p < yy_ch_buf + 2 ) X YY_FATAL_ERROR( "flex scanner push-back overflow" ); X } X X if ( yy_c_buf_p > yy_b_buf_p && yy_c_buf_p[-1] == '\n' ) X yy_c_buf_p[-2] = '\n'; X X *--yy_c_buf_p = c; X X YY_DO_BEFORE_ACTION; /* set up yytext again */ X } X X static int input() X X { X int c; X X YY_DO_BEFORE_SCAN; X X if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) X { /* need more input */ X yy_b_buf_p = yy_c_buf_p; X ++yy_c_buf_p; X X switch ( yy_get_next_buffer() ) X { X /* this code, unfortunately, is somewhat redundant with X * that above X */ X case EOB_ACT_END_OF_FILE: X { X if ( yywrap() ) X { X yy_c_buf_p = yy_b_buf_p; X return ( EOF ); X } X X yy_ch_buf[0] = '\n'; X yy_n_chars = 1; X yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; X yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; X yy_eof_has_been_seen = 0; X X YY_FAST_INIT; X X return ( input() ); X } X break; X X case EOB_ACT_RESTART_SCAN: X yy_c_buf_p = yy_b_buf_p; X break; X X case EOB_ACT_LAST_MATCH: X YY_FATAL_ERROR( "unexpected last match in input()" ); X } X } X X c = *yy_c_buf_p++; X X YY_DO_BEFORE_RESTART; X X return ( c ); X } END_OF_FILE if test 9304 -ne `wc -c <'flex.fastskel'`; then echo shar: \"'flex.fastskel'\" unpacked with wrong size! fi # end of 'flex.fastskel' fi if test -f 'main.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'main.c'\" else echo shar: Extracting \"'main.c'\" $12885 characters$ sed "s/^X//" >'main.c' <<'END_OF_FILE' X/* flex - tool to generate fast lexical analyzers X * X * X * Copyright (c) 1987, the University of California X * X * The United States Government has rights in this work pursuant to X * contract no. DE-AC03-76SF00098 between the United States Department of X * Energy and the University of California. X * X * This program may be redistributed. Enhancements and derivative works X * may be created provided the new works, if made available to the general X * public, are made available for use by anyone. X * X * X * ver date who remarks X * --- ---- ------ ------------------------------------------------------- X * 04b 30sep87 kg, vp .implemented (part of) Van Jacobson's fast scanner design X * 04a 27jun86 vp .translated from Ratfor into C X * 01a 22aug83 vp .written. Original version by Jef Poskanzer. X */ X X#include "flexdef.h" X X X/* these globals are all defined and commented in flexdef.h */ int printstats, syntaxerror, eofseen, ddebug, trace, spprdflt; int interactive, caseins, useecs, fulltbl, usemecs, reject; int fullspd, gen_line_dirs; int datapos, dataline, linenum; XFILE *skelfile = NULL; char *infilename = NULL; int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; int current_mns; int accnum, *firstst, *lastst, *finalst, *transchar; int *trans1, *trans2, *accptnum, lastnfa; int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1]; int tecbck[CSIZE + 1]; int lastsc, current_max_scs, *scset, *scbol, *scxclu, *actvsc; int current_max_dfa_size, current_max_xpairs; int current_max_template_xpairs, current_max_dfas; int lastdfa, *nxt, *chk, *tnxt; int *base, *def, tblend, firstfree, numtemps, **dss, *dfasiz; union dfaacc_union *dfaacc; int *accsiz, *dhash, *todo, todo_head, todo_next, numas; int numsnpairs, jambase, jamstate; int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse; int current_max_ccl_tbl_size; char *ccltbl; char *starttime, *endtime, nmstr[MAXLINE]; int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs; int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; XFILE *temp_action_file; int end_of_buffer_state; char *action_file_name = "/tmp/flexXXXXXX"; X X X/* flex - main program X * X * synopsis (from the shell) X * flex [-v] [file ...] X */ X main( argc, argv ) int argc; char **argv; X X { X flexinit( argc, argv ); X X readin(); X X if ( ! syntaxerror ) X { X /* convert the ndfa to a dfa */ X ntod(); X X /* generate the C state transition tables from the DFA */ X make_tables(); X } X X /* note, flexend does not return. It exits with its argument as status. */ X X flexend( 0 ); X } X X X/* flexend - terminate flex X * X * synopsis X * int status; X * flexend( status ); X * X * status is exit status. X * X * note X * This routine does not return. X */ X flexend( status ) int status; X X { X int tblsiz; X char *gettime(); X X if ( skelfile != NULL ) X (void) fclose( skelfile ); X X if ( temp_action_file ) X { X (void) fclose( temp_action_file ); X (void) unlink( action_file_name ); X } X X if ( printstats ) X { X endtime = gettime(); X X fprintf( stderr, "flex usage statistics:\n" ); X fprintf( stderr, " started at %s, finished at %s\n", X starttime, endtime ); X X fprintf( stderr, " %d/%d NFA states\n", lastnfa, current_mns ); X fprintf( stderr, " %d/%d DFA states (%d words)\n", lastdfa, X current_max_dfas, totnst ); X fprintf( stderr, " %d rules\n", accnum ); X fprintf( stderr, " %d/%d start conditions\n", lastsc, X current_max_scs ); X fprintf( stderr, " %d epsilon states, %d double epsilon states\n", X numeps, eps2 ); X X if ( lastccl == 0 ) X fprintf( stderr, " no character classes\n" ); X else X fprintf( stderr, X " %d/%d character classes needed %d/%d words of storage, %d reused\n", X lastccl, current_maxccls, X cclmap[lastccl] + ccllen[lastccl] - 1, X current_max_ccl_tbl_size, cclreuse ); X X fprintf( stderr, " %d state/nextstate pairs created\n", numsnpairs ); X fprintf( stderr, " %d/%d unique/duplicate transitions\n", X numuniq, numdup ); X X if ( fulltbl ) X { X tblsiz = lastdfa * numecs; X fprintf( stderr, " %d table entries\n", tblsiz ); X } X X else X { X tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend; X X fprintf( stderr, " %d/%d base/def entries created\n", X lastdfa + numtemps, current_max_dfas ); X fprintf( stderr, " %d/%d (peak %d) nxt/chk entries created\n", X tblend, current_max_xpairs, peakpairs ); X fprintf( stderr, X " %d/%d (peak %d) template nxt/chk entries created\n", X numtemps * nummecs, current_max_template_xpairs, X numtemps * numecs ); X fprintf( stderr, " %d empty table entries\n", nummt ); X fprintf( stderr, " %d protos created\n", numprots ); X fprintf( stderr, " %d templates created, %d uses\n", X numtemps, tmpuses ); X } X X if ( useecs ) X { X tblsiz = tblsiz + CSIZE; X fprintf( stderr, " %d/%d equivalence classes created\n", X numecs, CSIZE ); X } X X if ( usemecs ) X { X tblsiz = tblsiz + numecs; X fprintf( stderr, " %d/%d meta-equivalence classes created\n", X nummecs, CSIZE ); X } X X fprintf( stderr, " %d (%d saved) hash collisions, %d DFAs equal\n", X hshcol, hshsave, dfaeql ); X fprintf( stderr, " %d sets of reallocations needed\n", num_reallocs ); X fprintf( stderr, " %d total table entries needed\n", tblsiz ); X } X X exit( status ); X } X X X/* flexinit - initialize flex X * X * synopsis X * int argc; X * char **argv; X * flexinit( argc, argv ); X */ X flexinit( argc, argv ) int argc; char **argv; X X { X int i, sawcmpflag, use_stdout; X char *arg, *skelname = NULL, *gettime(), clower(), *mktemp(); X X printstats = syntaxerror = trace = spprdflt = interactive = caseins = false; X ddebug = fulltbl = reject = fullspd = false; X gen_line_dirs = usemecs = useecs = true; X X sawcmpflag = false; X use_stdout = false; X X /* read flags */ X for ( --argc, ++argv; argc ; --argc, ++argv ) X { X if ( argv[0][0] != '-' || argv[0][1] == '\0' ) X break; X X arg = argv[0]; X X for ( i = 1; arg[i] != '\0'; ++i ) X switch ( arg[i] ) X { X case 'c': X if ( i != 1 ) X flexerror( "-c flag must be given separately" ); X X if ( ! sawcmpflag ) X { X useecs = false; X usemecs = false; X fulltbl = false; X sawcmpflag = true; X } X X for ( ++i; arg[i] != '\0'; ++i ) X switch ( clower( arg[i] ) ) X { X case 'e': X useecs = true; X break; X X case 'F': X fullspd = true; X break; X X case 'f': X fulltbl = true; X break; X X case 'm': X usemecs = true; X break; X X default: X lerrif( "unknown -c option %c", X (int) arg[i] ); X break; X } X X goto get_next_arg; X X case 'd': X ddebug = true; X break; X X case 'f': X useecs = usemecs = false; X fulltbl = true; X break; X X case 'I': X interactive = true; X break; X X case 'i': X caseins = true; X break; X X case 'L': X gen_line_dirs = false; X break; X X case 'r': X reject = true; X break; X X case 'F': X useecs = usemecs = false; X fullspd = true; X break; X X case 'S': X if ( i != 1 ) X flexerror( "-S flag must be given separately" ); X X skelname = arg + i + 1; X goto get_next_arg; X X case 's': X spprdflt = true; X break; X X case 't': X use_stdout = true; X break; X X case 'T': X trace = true; X break; X X case 'v': X printstats = true; X break; X X default: X lerrif( "unknown flag %c", (int) arg[i] ); X break; X } X get_next_arg: /* used by -c and -S flags in lieu of a "continue 2" control */ X ; X } X X if ( (fulltbl || fullspd) && usemecs ) X flexerror( "full table and -cm don't make sense together" ); X X if ( (fulltbl || fullspd) && interactive ) X flexerror( "full table and -I are (currently) incompatible" ); X X if ( (fulltbl || fullspd) && reject ) X flexerror( "reject (-r) cannot be used with -f or -F" ); X X if ( fulltbl && fullspd ) X flexerror( "full table and -F are mutually exclusive" ); X X if ( ! skelname ) X { X static char skeleton_name_storage[400]; X X skelname = skeleton_name_storage; X X if ( fullspd || fulltbl ) X (void) strcpy( skelname, FAST_SKELETON_FILE ); X else X (void) strcpy( skelname, DEFAULT_SKELETON_FILE ); X } X X if ( ! use_stdout ) X { X FILE *prev_stdout = freopen( "lex.yy.c", "w", stdout ); X X if ( prev_stdout == NULL ) X flexerror( "could not create lex.yy.c" ); X } X X if ( argc ) X { X if ( argc > 1 ) X flexerror( "extraneous argument(s) given" ); X X yyin = fopen( infilename = argv[0], "r" ); X X if ( yyin == NULL ) X lerrsf( "can't open %s", argv[0] ); X } X X else X yyin = stdin; X X lastccl = 0; X lastsc = 0; X X /* initialize the statistics */ X starttime = gettime(); X X if ( (skelfile = fopen( skelname, "r" )) == NULL ) X lerrsf( "can't open skeleton file %s", skelname ); X X (void) mktemp( action_file_name ); X X if ( (temp_action_file = fopen( action_file_name, "w" )) == NULL ) X lerrsf( "can't open temporary action file %s", action_file_name ); X X lastdfa = lastnfa = accnum = numas = numsnpairs = tmpuses = 0; X numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0; X numuniq = numdup = hshsave = eofseen = datapos = dataline = 0; X onesp = numprots = 0; X X linenum = sectnum = 1; X firstprot = NIL; X X /* used in mkprot() so that the first proto goes in slot 1 X * of the proto queue X */ X lastprot = 1; X X if ( useecs ) X { X /* set up doubly-linked equivalence classes */ X ecgroup[1] = NIL; X X for ( i = 2; i <= CSIZE; ++i ) X { X ecgroup[i] = i - 1; X nextecm[i - 1] = i; X } X X nextecm[CSIZE] = NIL; X } X X else X { /* put everything in its own equivalence class */ X for ( i = 1; i <= CSIZE; ++i ) X { X ecgroup[i] = i; X nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ X } X } X X set_up_initial_allocations(); X } X X X/* readin - read in the rules section of the input file(s) X * X * synopsis X * readin(); X */ X readin() X X { X fputs( "#define YY_DEFAULT_ACTION ", stdout ); X X if ( spprdflt ) X fputs( "YY_FATAL_ERROR( \"flex scanner jammed\" )", stdout ); X else X fputs( "ECHO", stdout ); X X fputs( ";\n", stdout ); X X if ( ddebug ) X puts( "#define FLEX_DEBUG" ); X if ( useecs ) X puts( "#define FLEX_USE_ECS" ); X if ( usemecs ) X puts( "#define FLEX_USE_MECS" ); X if ( interactive ) X puts( "#define FLEX_INTERACTIVE_SCANNER" ); X if ( reject ) X puts( "#define FLEX_REJECT_ENABLED" ); X if ( fulltbl ) X puts( "#define FLEX_FULL_TABLE" ); X X skelout(); X X line_directive_out( stdout ); X X if ( yyparse() ) X lerrif( "fatal parse error at line %d", linenum ); X X if ( useecs ) X { X numecs = cre8ecs( nextecm, ecgroup, CSIZE ); X ccl2ecl(); X } X X else X numecs = CSIZE; X X } X X X X/* set_up_initial_allocations - allocate memory for internal tables */ X set_up_initial_allocations() X X { X current_mns = INITIAL_MNS; X firstst = allocate_integer_array( current_mns ); X lastst = allocate_integer_array( current_mns ); X finalst = allocate_integer_array( current_mns ); X transchar = allocate_integer_array( current_mns ); X trans1 = allocate_integer_array( current_mns ); X trans2 = allocate_integer_array( current_mns ); X accptnum = allocate_integer_array( current_mns ); X X current_max_scs = INITIAL_MAX_SCS; X scset = allocate_integer_array( current_max_scs ); X scbol = allocate_integer_array( current_max_scs ); X scxclu = allocate_integer_array( current_max_scs ); X actvsc = allocate_integer_array( current_max_scs ); X X current_maxccls = INITIAL_MAXCCLS; X cclmap = allocate_integer_array( current_maxccls ); X ccllen = allocate_integer_array( current_maxccls ); X cclng = allocate_integer_array( current_maxccls ); X X current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE; X ccltbl = allocate_character_array( current_max_ccl_tbl_size ); X X current_max_dfa_size = INITIAL_MAX_DFA_SIZE; X X current_max_xpairs = INITIAL_MAX_XPAIRS; X nxt = allocate_integer_array( current_max_xpairs ); X chk = allocate_integer_array( current_max_xpairs ); X X current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS; X tnxt = allocate_integer_array( current_max_template_xpairs ); X X current_max_dfas = INITIAL_MAX_DFAS; X base = allocate_integer_array( current_max_dfas ); X def = allocate_integer_array( current_max_dfas ); X dfasiz = allocate_integer_array( current_max_dfas ); X accsiz = allocate_integer_array( current_max_dfas ); X dhash = allocate_integer_array( current_max_dfas ); X todo = allocate_integer_array( current_max_dfas ); X dss = allocate_integer_pointer_array( current_max_dfas ); X dfaacc = allocate_dfaacc_union( current_max_dfas ); X } END_OF_FILE if test 12885 -ne `wc -c <'main.c'`; then echo shar: \"'main.c'\" unpacked with wrong size! fi # end of 'main.c' fi if test -f 'misc.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'misc.c'\" else echo shar: Extracting \"'misc.c'\" $9991 characters$ sed "s/^X//" >'misc.c' <<'END_OF_FILE' X/* misc - miscellaneous flex routines */ X X/* X * Copyright (c) 1987, the University of California X * X * The United States Government has rights in this work pursuant to X * contract no. DE-AC03-76SF00098 between the United States Department of X * Energy and the University of California. X * X * This program may be redistributed. Enhancements and derivative works X * may be created provided the new works, if made available to the general X * public, are made available for use by anyone. X */ X X#include <ctype.h> X#include "flexdef.h" X char *malloc(), *realloc(); X X X/* action_out - write the actions from the temporary file to lex.yy.c X * X * synopsis X * action_out(); X * X * Copies the action file up to %% (or end-of-file) to lex.yy.c X */ X action_out() X X { X char buf[MAXLINE]; X X while ( fgets( buf, MAXLINE, temp_action_file ) != NULL ) X if ( buf[0] == '%' && buf[1] == '%' ) X break; X else X fputs( buf, stdout ); X } X X X/* allocate_array - allocate memory for an integer array of the given size */ X char *allocate_array( size, element_size ) int size, element_size; X X { X register char *mem = malloc( (unsigned) (element_size * size) ); X X if ( mem == NULL ) X flexfatal( "memory allocation failed in allocate_array()" ); X X return ( mem ); X } X X X/* bubble - bubble sort an integer array in increasing order X * X * synopsis X * int v[n], n; X * bubble( v, n ); X * X * description X * sorts the first n elements of array v and replaces them in X * increasing order. X * X * passed X * v - the array to be sorted X * n - the number of elements of 'v' to be sorted */ X bubble( v, n ) int v[], n; X X { X register int i, j, k; X X for ( i = n; i > 1; --i ) X for ( j = 1; j < i; ++j ) X if ( v[j] > v[j + 1] ) /* compare */ X { X k = v[j]; /* exchange */ X v[j] = v[j + 1]; X v[j + 1] = k; X } X } X X X/* clower - replace upper-case letter to lower-case X * X * synopsis: X * char clower(), c; X * c = clower( c ); X */ X char clower( c ) register char c; X X { X return ( isupper(c) ? tolower(c) : c ); X } X X X/* copy_string - returns a dynamically allocated copy of a string X * X * synopsis X * char *str, *copy, *copy_string(); X * copy = copy_string( str ); X */ X char *copy_string( str ) register char *str; X X { X register char *c; X char *copy; X X /* find length */ X for ( c = str; *c; ++c ) X ; X X copy = malloc( (unsigned) ((c - str + 1) * sizeof( char )) ); X X if ( copy == NULL ) X flexfatal( "dynamic memory failure in copy_string()" ); X X for ( c = copy; (*c++ = *str++); ) X ; X X return ( copy ); X } X X X/* cshell - shell sort a character array in increasing order X * X * synopsis X * X * char v[n]; X * int n; X * cshell( v, n ); X * X * description X * does a shell sort of the first n elements of array v. X * X * passed X * v - array to be sorted X * n - number of elements of v to be sorted X */ cshell( v, n ) char v[]; int n; X X { X int gap, i, j, jg; X char k; X X for ( gap = n / 2; gap > 0; gap = gap / 2 ) X for ( i = gap; i < n; ++i ) X for ( j = i - gap; j >= 0; j = j - gap ) X { X jg = j + gap; X X if ( v[j] <= v[jg] ) X break; X X k = v[j]; X v[j] = v[jg]; X v[jg] = k; X } X } X X X/* dataend - finish up a block of data declarations X * X * synopsis X * dataend(); X */ dataend() X X { X if ( datapos > 0 ) X dataflush(); X X /* add terminator for initialization */ X puts( " } ;\n" ); X X dataline = 0; X } X X X X/* dataflush - flush generated data statements X * X * synopsis X * dataflush(); X */ dataflush() X X { X putchar( '\n' ); X X if ( ++dataline >= NUMDATALINES ) X { X /* put out a blank line so that the table is grouped into X * large blocks that enable the user to find elements easily X */ X putchar( '\n' ); X dataline = 0; X } X X /* reset the number of characters written on the current line */ X datapos = 0; X } X X/* gettime - return current time X * X * synopsis X * char *gettime(), *time_str; X * time_str = gettime(); X */ X X/* include sys/types.h to use time_t and make lint happy */ X X#include <sys/types.h> X char *gettime() X X { X time_t t, time(); X char *result, *ctime(), *copy_string(); X X t = time( (long *) 0 ); X X result = copy_string( ctime( &t ) ); X X /* get rid of trailing newline */ X result[24] = '\0'; X X return ( result ); X } X X X/* lerrif - report an error message formatted with one integer argument X * X * synopsis X * char msg[]; X * int arg; X * lerrif( msg, arg ); X */ X lerrif( msg, arg ) char msg[]; int arg; X X { X char errmsg[MAXLINE]; X (void) sprintf( errmsg, msg, arg ); X flexerror( errmsg ); X } X X X/* lerrsf - report an error message formatted with one string argument X * X * synopsis X * char msg[], arg[]; X * lerrsf( msg, arg ); X */ X lerrsf( msg, arg ) char msg[], arg[]; X X { X char errmsg[MAXLINE]; X X (void) sprintf( errmsg, msg, arg ); X flexerror( errmsg ); X } X X X/* flexerror - report an error message and terminate X * X * synopsis X * char msg[]; X * flexerror( msg ); X */ X flexerror( msg ) char msg[]; X X { X fprintf( stderr, "flex: %s\n", msg ); X flexend( 1 ); X } X X X/* flexfatal - report a fatal error message and terminate X * X * synopsis X * char msg[]; X * flexfatal( msg ); X */ X flexfatal( msg ) char msg[]; X X { X fprintf( stderr, "flex: fatal internal error %s\n", msg ); X flexend( 1 ); X } X X X/* line_directive_out - spit out a "# line" statement */ X line_directive_out( output_file_name ) XFILE *output_file_name; X X { X if ( infilename && gen_line_dirs ) X fprintf( output_file_name, "# line %d \"%s\"\n", linenum, infilename ); X } X X X/* mk2data - generate a data statement for a two-dimensional array X * X * synopsis X * int value; X * mk2data( value ); X * X * generates a data statement initializing the current 2-D array to "value" X */ mk2data( value ) int value; X X { X if ( datapos >= NUMDATAITEMS ) X { X putchar( ',' ); X dataflush(); X } X X if ( datapos == 0 ) X /* indent */ X fputs( " ", stdout ); X X else X putchar( ',' ); X X ++datapos; X X printf( "%5d", value ); X } X X X/* mkdata - generate a data statement X * X * synopsis X * int value; X * mkdata( value ); X * X * generates a data statement initializing the current array element to X * "value" X */ mkdata( value ) int value; X X { X if ( datapos >= NUMDATAITEMS ) X { X putchar( ',' ); X dataflush(); X } X X if ( datapos == 0 ) X /* indent */ X fputs( " ", stdout ); X X else X putchar( ',' ); X X ++datapos; X X printf( "%5d", value ); X } X X X/* myctoi - return the integer represented by a string of digits X * X * synopsis X * char array[]; X * int val, myctoi(); X * val = myctoi( array ); X * X */ X int myctoi( array ) char array[]; X X { X int val = 0; X X (void) sscanf( array, "%d", &val ); X X return ( val ); X } X X X/* myesc - return character corresponding to escape sequence X * X * synopsis X * char array[], c, myesc(); X * c = myesc( array ); X * X */ X char myesc( array ) char array[]; X X { X switch ( array[1] ) X { X case 'n': return ( '\n' ); X case 't': return ( '\t' ); X case 'f': return ( '\f' ); X case 'r': return ( '\r' ); X case 'b': return ( '\b' ); X X case '0': X if ( isdigit(array[2]) ) X { /* \0<octal> */ X char c, esc_char; X register int sptr = 2; X X while ( isdigit(array[sptr]) ) X /* don't increment inside loop control because the X * macro will expand it to two increments! (Not a X * problem with the C version of the macro) X */ X ++sptr; X X c = array[sptr]; X array[sptr] = '\0'; X X esc_char = otoi( array + 2 ); X array[sptr] = c; X X if ( esc_char == '\0' ) X { X synerr( "escape sequence for null not allowed" ); X return ( 1 ); X } X X return ( esc_char ); X } X X else X { X synerr( "escape sequence for null not allowed" ); X return ( 1 ); X } X X#ifdef NOTDEF X case '^': X { X register char next_char = array[2]; X X if ( next_char == '?' ) X return ( 0x7f ); X X else if ( next_char >= 'A' && next_char <= 'Z' ) X return ( next_char - 'A' + 1 ); X X else if ( next_char >= 'a' && next_char <= 'z' ) X return ( next_char - 'z' + 1 ); X X synerr( "illegal \\^ escape sequence" ); X X return ( 1 ); X } X#endif X } X X return ( array[1] ); X } X X X/* otoi - convert an octal digit string to an integer value X * X * synopsis: X * int val, otoi(); X * char str[]; X * val = otoi( str ); X */ X int otoi( str ) char str[]; X X { X#ifdef FTLSOURCE X fortran int gctoi() X int dummy = 1; X X return ( gctoi( str, dummy, 8 ) ); X#else X int result; X X (void) sscanf( str, "%o", &result ); X X return ( result ); X#endif X } X X X X X/* reallocate_array - increase the size of a dynamic array */ X char *reallocate_array( array, size, element_size ) char *array; int size, element_size; X X { X register char *new_array = realloc( array, X (unsigned) (size * element_size )); X X if ( new_array == NULL ) X flexfatal( "attempt to increase array size failed" ); X X return ( new_array ); X } X X X/* skelout - write out one section of the skeleton file X * X * synopsis X * skelout(); X * X * DESCRIPTION X * Copies from skelfile to stdout until a line beginning with "%%" or X * EOF is found. X */ skelout() X X { X char buf[MAXLINE]; X X while ( fgets( buf, MAXLINE, skelfile ) != NULL ) X if ( buf[0] == '%' && buf[1] == '%' ) X break; X else X fputs( buf, stdout ); X } X X X/* transition_struct_out - output a yy_trans_info structure X * X * synopsis X * int element_v, element_n; X * transition_struct_out( element_v, element_n ); X * X * outputs the yy_trans_info structure with the two elements, element_v and X * element_n. Formats the output with spaces and carriage returns. X */ X transition_struct_out( element_v, element_n ) int element_v, element_n; X X { X printf( "%7d, %5d,", element_v, element_n ); X X datapos += TRANS_STRUCT_PRINT_LENGTH; X X if ( datapos >= 75 ) X { X printf( "\n" ); X X if ( ++dataline % 10 == 0 ) X printf( "\n" ); X X datapos = 0; X } X } END_OF_FILE if test 9991 -ne `wc -c <'misc.c'`; then echo shar: \"'misc.c'\" unpacked with wrong size! fi # end of 'misc.c' fi if test -f 'scan.l' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'scan.l'\" else echo shar: Extracting \"'scan.l'\" $9189 characters$ sed "s/^X//" >'scan.l' <<'END_OF_FILE' X/* scan.l - scanner for flex input */ X X/* X * Copyright (c) 1987, the University of California X * X * The United States Government has rights in this work pursuant to X * contract no. DE-AC03-76SF00098 between the United States Department of X * Energy and the University of California. X * X * This program may be redistributed. Enhancements and derivative works X * may be created provided the new works, if made available to the general X * public, are made available for use by anyone. X */ X X%{ X#include "flexdef.h" X#include "parse.h" X X#define ACTION_ECHO fprintf( temp_action_file, "%s", yytext ) X#define MARK_END_OF_PROLOG fprintf( temp_action_file, "%%%% end of prolog\n" ); X X#undef YY_DECL X#define YY_DECL \ X int flexscan() X X#define RETURNCHAR \ X yylval = yytext[0]; \ X return ( CHAR ); X X#define RETURNNAME \ X (void) strcpy( nmstr, yytext ); \ X return ( NAME ); X X#define PUT_BACK_STRING(str, start) \ X for ( i = strlen( str ) - 1; i >= start; --i ) \ X unput(str[i]) X%} X X%x SECT2 SECT2PROLOG SECT3 CODEBLOCK PICKUPDEF SC CARETISBOL NUM QUOTE X%x FIRSTCCL CCL ACTION RECOVER BRACEERROR C_COMMENT C_COMMENT_2 ACTION_COMMENT X%x ACTION_STRING PERCENT_BRACE_ACTION X WS [ \t]+ X OPTWS [ \t]* X NAME [a-z_][a-z_0-9]* X SCNAME {NAME} X ESCSEQ \\([^^\n]|"^".|0[0-9]{1,3}) X X%% X static int bracelevel, didadef; X int i, cclval; X char nmdef[MAXLINE], myesc(); X X^{WS}.*\n ++linenum; ECHO; /* indented code */ X^#.*\n ++linenum; ECHO; /* treat as a comment */ X^"/*" ECHO; BEGIN(C_COMMENT); X^"%s"(tart)? return ( SCDECL ); X^"%x" return ( XSCDECL ); X^"%{".*\n ++linenum; line_directive_out( stdout ); BEGIN(CODEBLOCK); X{WS} return ( WHITESPACE ); X X^"%%".* { X sectnum = 2; X line_directive_out( stdout ); X BEGIN(SECT2PROLOG); X return ( SECTEND ); X } X X^"%"[^sx{%].*\n { X fprintf( stderr, X "old-style lex command at line %d ignored:\n\t%s", X linenum, yytext ); X ++linenum; X } X X^{NAME} { X (void) strcpy( nmstr, yytext ); X didadef = false; X BEGIN(PICKUPDEF); X } X X{SCNAME} RETURNNAME; X^{OPTWS}\n ++linenum; /* allows blank lines in section 1 */ X\n ++linenum; return ( '\n' ); X. synerr( "illegal character" ); BEGIN(RECOVER); X X X<C_COMMENT>"*/" ECHO; BEGIN(0); X<C_COMMENT>"*/".*\n ++linenum; ECHO; BEGIN(0); X<C_COMMENT>[^*\n]+ ECHO; X<C_COMMENT>"*" ECHO; X<C_COMMENT>\n ++linenum; ECHO; X X<CODEBLOCK>^"%}".*\n ++linenum; BEGIN(0); X<CODEBLOCK>.*\n ++linenum; ECHO; X X<PICKUPDEF>{WS} /* separates name and definition */ X X<PICKUPDEF>[^ \t\n].* { X (void) strcpy( nmdef, yytext ); X X for ( i = strlen( nmdef ) - 1; X i >= 0 && X nmdef[i] == ' ' || nmdef[i] == '\t'; X --i ) X ; X X nmdef[i + 1] = '\0'; X X ndinstal( nmstr, nmdef ); X didadef = true; X } X X<PICKUPDEF>\n { X if ( ! didadef ) X synerr( "incomplete name definition" ); X BEGIN(0); X ++linenum; X } X X<RECOVER>.*\n ++linenum; BEGIN(0); RETURNNAME; X X X<SECT2PROLOG>.*\n/[^ \t\n] { X ++linenum; X ACTION_ECHO; X MARK_END_OF_PROLOG; X BEGIN(SECT2); X } X X<SECT2PROLOG>.*\n ++linenum; ACTION_ECHO; X X<SECT2>^{OPTWS}\n ++linenum; /* allow blank lines in section 2 */ X X /* this horrible mess of a rule matches indented lines which X * do not contain "/*". We need to make the distinction because X * otherwise this rule will be taken instead of the rule which X * matches the beginning of comments like this one X */ X<SECT2>^{WS}([^/\n]|"/"[^*\n])*("/"?)\n { X synerr( "indented code found outside of action" ); X ++linenum; X } X X<SECT2>"<" BEGIN(SC); return ( '<' ); X<SECT2>^"^" return ( '^' ); X<SECT2>\" BEGIN(QUOTE); return ( '"' ); X<SECT2>"{"/[0-9] BEGIN(NUM); return ( '{' ); X<SECT2>"{"[^0-9\n][^}\n]* BEGIN(BRACEERROR); X<SECT2>"$"/[ \t\n] return ( '$' ); X X<SECT2>{WS}"%{" { X bracelevel = 1; X BEGIN(PERCENT_BRACE_ACTION); X return ( '\n' ); X } X<SECT2>{WS}"|".*\n ++linenum; return ( '\n' ); X X<SECT2>^{OPTWS}"/*" ACTION_ECHO; BEGIN(C_COMMENT_2); X X<SECT2>{WS} { /* needs to be separate from following rule due to X * bug with trailing context X */ X bracelevel = 0; X BEGIN(ACTION); X return ( '\n' ); X } X X<SECT2>{OPTWS}/\n { X bracelevel = 0; X BEGIN(ACTION); X return ( '\n' ); X } X X<SECT2>^{OPTWS}\n ++linenum; return ( '\n' ); X X<SECT2>^"%%".* { X /* guarantee that the SECT3 rule will have something X * to match X */ X yyless(1); X sectnum = 3; X BEGIN(SECT3); X return ( EOF ); /* to stop the parser */ X } X X<SECT2>"["([^\\\]\n]|{ESCSEQ})+"]" { X (void) strcpy( nmstr, yytext ); X X /* check to see if we've already encountered this ccl */ X if ( (cclval = ccllookup( nmstr )) ) X { X yylval = cclval; X ++cclreuse; X return ( PREVCCL ); X } X else X { X /* we fudge a bit. We know that this ccl will X * soon be numbered as lastccl + 1 by cclinit X */ X cclinstal( nmstr, lastccl + 1 ); X X /* push back everything but the leading bracket X * so the ccl can be rescanned X */ X PUT_BACK_STRING(nmstr, 1); X X BEGIN(FIRSTCCL); X return ( '[' ); X } X } X X<SECT2>"{"{NAME}"}" { X register char *nmdefptr; X char *ndlookup(); X X (void) strcpy( nmstr, yytext ); X nmstr[yyleng - 1] = '\0'; /* chop trailing brace */ X X /* lookup from "nmstr + 1" to chop leading brace */ X if ( ! (nmdefptr = ndlookup( nmstr + 1 )) ) X synerr( "undefined {name}" ); X X else X { /* push back name surrounded by ()'s */ X unput(')'); X PUT_BACK_STRING(nmdefptr, 0); X unput('('); X } X } X X<SECT2>[/|*+?.()] return ( yytext[0] ); X<SECT2>. RETURNCHAR; X<SECT2>\n ++linenum; return ( '\n' ); X X X<SC>"," return ( ',' ); X<SC>">" BEGIN(SECT2); return ( '>' ); X<SC>">"/"^" BEGIN(CARETISBOL); return ( '>' ); X<SC>{SCNAME} RETURNNAME; X<SC>. synerr( "bad start condition name" ); X X<CARETISBOL>"^" BEGIN(SECT2); return ( '^' ); X X X<QUOTE>[^"\n] RETURNCHAR; X<QUOTE>\" BEGIN(SECT2); return ( '"' ); X X<QUOTE>\n { X synerr( "missing quote" ); X BEGIN(SECT2); X ++linenum; X return ( '"' ); X } X X X<FIRSTCCL>"^"/[^-\n] BEGIN(CCL); return ( '^' ); X<FIRSTCCL>"^"/- return ( '^' ); X<FIRSTCCL>- BEGIN(CCL); yylval = '-'; return ( CHAR ); X<FIRSTCCL>. BEGIN(CCL); RETURNCHAR; X X<CCL>-/[^\]\n] return ( '-' ); X<CCL>[^\]\n] RETURNCHAR; X<CCL>"]" BEGIN(SECT2); return ( ']' ); X X X<NUM>[0-9]+ { X yylval = myctoi( yytext ); X return ( NUMBER ); X } X X<NUM>"," return ( ',' ); X<NUM>"}" BEGIN(SECT2); return ( '}' ); X X<NUM>. { X synerr( "bad character inside {}'s" ); X BEGIN(SECT2); X return ( '}' ); X } X X<NUM>\n { X synerr( "missing }" ); X BEGIN(SECT2); X ++linenum; X return ( '}' ); X } X X X<BRACEERROR>"}" synerr( "bad name in {}'s" ); BEGIN(SECT2); X<BRACEERROR>\n synerr( "missing }" ); ++linenum; BEGIN(SECT2); X X X<PERCENT_BRACE_ACTION>{OPTWS}"%}".* bracelevel = 0; X<PERCENT_BRACE_ACTION>.* ACTION_ECHO; X<PERCENT_BRACE_ACTION>\n { X ++linenum; X ACTION_ECHO; X if ( bracelevel == 0 ) X { X fputs( "\tYY_BREAK\n", temp_action_file ); X BEGIN(SECT2); X } X } X X<ACTION>"{" ACTION_ECHO; ++bracelevel; X<ACTION>"}" ACTION_ECHO; --bracelevel; X<ACTION>[^{}"'/\n]+ ACTION_ECHO; X<ACTION>"/*" ACTION_ECHO; BEGIN(ACTION_COMMENT); X<ACTION>"'"([^'\\\n]|\\.)*"'" ACTION_ECHO; /* character constant */ X<ACTION>\" ACTION_ECHO; BEGIN(ACTION_STRING); X<ACTION>\n { X ++linenum; X ACTION_ECHO; X if ( bracelevel == 0 ) X { X fputs( "\tYY_BREAK\n", temp_action_file ); X BEGIN(SECT2); X } X } X<ACTION>. ACTION_ECHO; X X<ACTION_COMMENT>"*/" ACTION_ECHO; BEGIN(ACTION); X<ACTION_COMMENT>[^*\n]+ ACTION_ECHO; X<ACTION_COMMENT>"*" ACTION_ECHO; X<ACTION_COMMENT>\n ++linenum; ACTION_ECHO; X<ACTION_COMMENT>. ACTION_ECHO; X X<C_COMMENT_2>"*/" ACTION_ECHO; BEGIN(SECT2); X<C_COMMENT_2>"*/".*\n ++linenum; ACTION_ECHO; BEGIN(SECT2); X<C_COMMENT_2>[^*\n]+ ACTION_ECHO; X<C_COMMENT_2>"*" ACTION_ECHO; X<C_COMMENT_2>\n ++linenum; ACTION_ECHO; X X<ACTION_STRING>[^"\\\n]+ ACTION_ECHO; X<ACTION_STRING>\\. ACTION_ECHO; X<ACTION_STRING>\n ++linenum; ACTION_ECHO; X<ACTION_STRING>\" ACTION_ECHO; BEGIN(ACTION); X<ACTION_STRING>. ACTION_ECHO; X X X<SECT2,QUOTE,CCL>{ESCSEQ} { X yylval = myesc( yytext ); X return ( CHAR ); X } X X<FIRSTCCL>{ESCSEQ} { X yylval = myesc( yytext ); X BEGIN(CCL); X return ( CHAR ); X } X X X<SECT3>.|\n { X register int numchars; X X /* black magic - we know the names of a flex scanner's X * internal variables. We cap the input buffer with X * an end-of-string and dump it to the output. X */ X YY_DO_BEFORE_SCAN; /* recover from setting up yytext */ X X#ifdef FLEX_FAST_SKEL X fputs( yy_c_buf_p + 1, stdout ); X#else X yy_ch_buf[yy_e_buf_p + 1] = '\0'; X X /* ignore the first character; it's the second '%' X * put back by the yyless(1) above X */ X fputs( yy_ch_buf + yy_c_buf_p + 1, stdout ); X#endif X X /* if we don't do this, the data written by write() X * can get overwritten when stdout is finally flushed X */ X (void) fflush( stdout ); X X while ( (numchars = read( fileno(yyin), yy_ch_buf, X YY_BUF_MAX )) > 0 ) X (void) write( fileno(stdout), yy_ch_buf, numchars ); X X if ( numchars < 0 ) X flexerror( "fatal read error in section 3" ); X X return ( EOF ); X } X%% END_OF_FILE if test 9189 -ne `wc -c <'scan.l'`; then echo shar: \"'scan.l'\" unpacked with wrong size! fi # end of 'scan.l' fi echo shar: End of archive 2 $of 5$. cp /dev/null ark2isdone MISSING="" for I in 1 2 3 4 5 ; do if test ! -f ark${I}isdone ; then MISSING="${MISSING} ${I}" fi done if test "${MISSING}" = "" ; then echo You have unpacked all 5 archives. rm -f ark[1-9]isdone else echo You still need to unpack the following archives: echo " " ${MISSING} fi ## End of shell archive. exit 0